ಪೈಥಾನ್ Ast ಮಾಡ್ಯೂಲ್: ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ ಡಿಮಿಸ್ಟಿಫೈಡ್

ಪೈಥಾನ್ ast ಮಾಡ್ಯೂಲ್ ಪೈಥಾನ್ ಕೋಡ್‌ನ ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ (AST) ಜೊತೆಗೆ ಸಂವಹನ ನಡೆಸಲು ಒಂದು ಪ್ರಬಲ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಒಂದು AST ಎಂದರೆ ಸೋರ್ಸ್ ಕೋಡ್‌ನ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ರಚನೆಯ ಟ್ರೀ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದ್ದು, ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸಲು, ಮಾರ್ಪಡಿಸಲು ಮತ್ತು ಉತ್ಪಾದಿಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ಇದು ಕೋಡ್ ವಿಶ್ಲೇಷಣೆ ಪರಿಕರಗಳು, ಸ್ವಯಂಚಾಲಿತ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್, ಸ್ಥಿರ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಕಸ್ಟಮ್ ಭಾಷಾ ವಿಸ್ತರಣೆಗಳು ಸೇರಿದಂತೆ ವಿವಿಧ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಬಾಗಿಲು ತೆರೆಯುತ್ತದೆ. ಈ ಲೇಖನವು ast ಮಾಡ್ಯೂಲ್‌ನ ಮೂಲಭೂತ ಅಂಶಗಳ ಮೂಲಕ ನಿಮಗೆ ಮಾರ್ಗದರ್ಶನ ನೀಡುತ್ತದೆ, ಅದರ ಸಾಮರ್ಥ್ಯಗಳ ಬಗ್ಗೆ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಒಳನೋಟಗಳನ್ನು ನೀಡುತ್ತದೆ.

ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ (AST) ಎಂದರೇನು?

ast ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವ ಮೊದಲು, ಅಬ್ಸ್ಟ್ರಾಕ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ ಎಂದರೇನು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ. ಪೈಥಾನ್ ಇಂಟರ್‌ಪ್ರಿಟರ್ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ಮೊದಲ ಹಂತವೆಂದರೆ ಕೋಡ್ ಅನ್ನು AST ಆಗಿ ಪಾರ್ಸ್ ಮಾಡುವುದು. ಈ ಟ್ರೀ ರಚನೆಯು ಕಾರ್ಯಗಳು, ತರಗತಿಗಳು, ಲೂಪ್‌ಗಳು, ಅಭಿವ್ಯಕ್ತಿಗಳು ಮತ್ತು ಆಪರೇಟರ್‌ಗಳಂತಹ ಕೋಡ್‌ನ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ಅಂಶಗಳನ್ನು ಅವುಗಳ ಸಂಬಂಧಗಳೊಂದಿಗೆ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. AST ವೈಟ್‌ಸ್ಪೇಸ್ ಮತ್ತು ಕಾಮೆಂಟ್‌ಗಳಂತಹ ಅಪ್ರಸ್ತುತ ವಿವರಗಳನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ, ಅಗತ್ಯ ರಚನಾತ್ಮಕ ಮಾಹಿತಿಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ. ಈ ರೀತಿಯಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಮೂಲಕ, ಪ್ರೋಗ್ರಾಂಗಳು ಕೋಡ್ ಅನ್ನು ಸ್ವತಃ ವಿಶ್ಲೇಷಿಸಲು ಮತ್ತು ಮಾರ್ಪಡಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಇದು ಹಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಹಳ ಉಪಯುಕ್ತವಾಗಿದೆ.

ast ಮಾಡ್ಯೂಲ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು

ast ಮಾಡ್ಯೂಲ್ ಪೈಥಾನ್‌ನ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯ ಭಾಗವಾಗಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ಅದನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಲು ಸರಳವಾಗಿ ಆಮದು ಮಾಡಿ:

            import ast
            

              
                Copy
              
            
          

ast ಮಾಡ್ಯೂಲ್‌ನ ಪ್ರಮುಖ ಕಾರ್ಯವೆಂದರೆ ast.parse(), ಇದು ಪೈಥಾನ್ ಕೋಡ್‌ನ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು AST ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast_tree)
            

              
                Copy
              
            
          

ಇದು ಈ ರೀತಿಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೀಡುತ್ತದೆ: <_ast.Module object at 0x...>. ಈ ಔಟ್‌ಪುಟ್ ನಿರ್ದಿಷ್ಟವಾಗಿ ತಿಳಿವಳಿಕೆಯಿಲ್ಲದಿದ್ದರೂ, ಕೋಡ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ AST ಆಗಿ ಪಾರ್ಸ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ. ast_tree ವಸ್ತುವು ಈಗ ಪಾರ್ಸ್ ಮಾಡಿದ ಕೋಡ್‌ನ ಸಂಪೂರ್ಣ ರಚನೆಯನ್ನು ಒಳಗೊಂಡಿದೆ.

AST ಅನ್ನು ಅನ್ವೇಷಿಸುವುದು

AST ಯ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ನಾವು ast.dump() ಕಾರ್ಯವನ್ನು ಬಳಸಬಹುದು. ಈ ಕಾರ್ಯವು ಟ್ರೀ ಅನ್ನು ಪುನರಾವರ್ತಿತವಾಗಿ ಹಾದುಹೋಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ನೋಡ್‌ನ ವಿವರವಾದ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast.dump(ast_tree, indent=4))
            

              
                Copy
              
            
          

ಔಟ್‌ಪುಟ್ ಹೀಗಿರುತ್ತದೆ:

            Module(
    body=[
        FunctionDef(
            name='add',
            args=arguments(
                posonlyargs=[],
                args=[
                    arg(arg='x', annotation=None, type_comment=None),
                    arg(arg='y', annotation=None, type_comment=None)
                ],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                Return(
                    value=BinOp(
                        left=Name(id='x', ctx=Load()),
                        op=Add(),
                        right=Name(id='y', ctx=Load())
                    )
                )
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    type_ignores=[]
)
            

              
                Copy
              
            
          

ಈ ಔಟ್‌ಪುಟ್ ಕೋಡ್‌ನ ಕ್ರಮಾನುಗತ ರಚನೆಯನ್ನು ತೋರಿಸುತ್ತದೆ. ಅದನ್ನು ವಿಭಜಿಸೋಣ:

• Module: ಸಂಪೂರ್ಣ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಮೂಲ ನೋಡ್.
• body: ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿನ ಹೇಳಿಕೆಗಳ ಪಟ್ಟಿ.
• FunctionDef: ಒಂದು ಫಂಕ್ಷನ್ ಡೆಫಿನಿಷನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದರ ಗುಣಲಕ್ಷಣಗಳು ಒಳಗೊಂಡಿವೆ:
• name: ಫಂಕ್ಷನ್‌ನ ಹೆಸರು ('add').
• args: ಫಂಕ್ಷನ್‌ನ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು.
• arguments: ಫಂಕ್ಷನ್‌ನ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.
• arg: ಒಂದು ಸಿಂಗಲ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ (ಉದಾ., 'x', 'y').
• body: ಫಂಕ್ಷನ್‌ನ ಬಾಡಿ (ಹೇಳಿಕೆಗಳ ಪಟ್ಟಿ).
• Return: ರಿಟರ್ನ್ ಹೇಳಿಕೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
• value: ಹಿಂತಿರುಗಿಸಲ್ಪಡುವ ಮೌಲ್ಯ.
• BinOp: ಒಂದು ಬೈನರಿ ಆಪರೇಷನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ (ಉದಾ., x + y).
• left: ಎಡ ಅಪರಾಂಡ್ (ಉದಾ., 'x').
• op: ಆಪರೇಟರ್ (ಉದಾ., 'Add').
• right: ಬಲ ಅಪರಾಂಡ್ (ಉದಾ., 'y').

AST ಅನ್ನು ಟ್ರಾವರ್ಸ್ ಮಾಡುವುದು

ast ಮಾಡ್ಯೂಲ್ AST ಅನ್ನು ಟ್ರಾವರ್ಸ್ ಮಾಡಲು ast.NodeVisitor ತರಗತಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ast.NodeVisitor ಅನ್ನು ಉಪವರ್ಗೀಕರಿಸುವ ಮೂಲಕ ಮತ್ತು ಅದರ ವಿಧಾನಗಳನ್ನು ಓವರ್‌ರೈಡ್ ಮಾಡುವ ಮೂಲಕ, ಟ್ರಾವರ್ಸಲ್ ಸಮಯದಲ್ಲಿ ಎದುರಾದಾಗ ನಿರ್ದಿಷ್ಟ ನೋಡ್ ಪ್ರಕಾರಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು. ಕೋಡ್ ರಚನೆಯನ್ನು ವಿಶ್ಲೇಷಿಸಲು, ನಿರ್ದಿಷ್ಟ ಮಾದರಿಗಳನ್ನು ಗುರುತಿಸಲು ಅಥವಾ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆಯಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

            import ast

class FunctionNameExtractor(ast.NodeVisitor):
    def __init__(self):
        self.function_names = []

    def visit_FunctionDef(self, node):
        self.function_names.append(node.name)

code = """
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y
"""

ast_tree = ast.parse(code)

extractor = FunctionNameExtractor()
extractor.visit(ast_tree)

print(extractor.function_names)  # Output: ['add', 'subtract']
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, FunctionNameExtractor ast.NodeVisitor ನಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತದೆ ಮತ್ತು visit_FunctionDef ವಿಧಾನವನ್ನು ಓವರ್‌ರೈಡ್ ಮಾಡುತ್ತದೆ. ಈ ವಿಧಾನವನ್ನು AST ಯಲ್ಲಿನ ಪ್ರತಿ ಫಂಕ್ಷನ್ ಡೆಫಿನಿಷನ್ ನೋಡ್‌ಗಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ. ವಿಧಾನವು ಫಂಕ್ಷನ್ ಹೆಸರನ್ನು function_names ಪಟ್ಟಿಗೆ ಸೇರಿಸುತ್ತದೆ. visit() ವಿಧಾನವು AST ಯ ಟ್ರಾವರ್ಸಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ಎಲ್ಲಾ ವೇರಿಯಬಲ್ ಅಸೈನ್‌ಮೆಂಟ್‌ಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು

            import ast

class VariableAssignmentFinder(ast.NodeVisitor):
    def __init__(self):
        self.assignments = []

    def visit_Assign(self, node):
        for target in node.targets:
            if isinstance(target, ast.Name):
                self.assignments.append(target.id)

code = """
x = 10
y = x + 5
message = \"hello\" 
"""

ast_tree = ast.parse(code)

finder = VariableAssignmentFinder()
finder.visit(ast_tree)

print(finder.assignments)  # Output: ['x', 'y', 'message']
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ಕೋಡ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ವೇರಿಯಬಲ್ ಅಸೈನ್‌ಮೆಂಟ್‌ಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ. ಪ್ರತಿ ಅಸೈನ್‌ಮೆಂಟ್ ಹೇಳಿಕೆಗಾಗಿ visit_Assign ವಿಧಾನವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದು ಅಸೈನ್‌ಮೆಂಟ್‌ನ ಟಾರ್ಗೆಟ್‌ಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಒಂದು ಟಾರ್ಗೆಟ್ ಸರಳ ಹೆಸರಾಗಿದ್ದರೆ (ast.Name), ಅದು ಹೆಸರನ್ನು assignments ಪಟ್ಟಿಗೆ ಸೇರಿಸುತ್ತದೆ.

AST ಅನ್ನು ಮಾರ್ಪಡಿಸುವುದು

ast ಮಾಡ್ಯೂಲ್ AST ಅನ್ನು ಮಾರ್ಪಡಿಸಲು ಸಹ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ನೋಡ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು, ಹೊಸ ನೋಡ್‌ಗಳನ್ನು ಸೇರಿಸಬಹುದು ಅಥವಾ ಒಟ್ಟಿಗೆ ನೋಡ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಬಹುದು. AST ಅನ್ನು ಮಾರ್ಪಡಿಸಲು, ನೀವು ast.NodeTransformer ತರಗತಿಯನ್ನು ಬಳಸುತ್ತೀರಿ. ast.NodeVisitor ಅನ್ನು ಹೋಲುವಂತೆ, ನೀವು ast.NodeTransformer ಅನ್ನು ಉಪವರ್ಗೀಕರಿಸುತ್ತೀರಿ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ನೋಡ್ ಪ್ರಕಾರಗಳನ್ನು ಮಾರ್ಪಡಿಸಲು ಅದರ ವಿಧಾನಗಳನ್ನು ಓವರ್‌ರೈಡ್ ಮಾಡಿ. ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೆಂದರೆ ast.NodeTransformer ವಿಧಾನಗಳು ಮಾರ್ಪಡಿಸಿದ ನೋಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು (ಅಥವಾ ಅದನ್ನು ಬದಲಾಯಿಸಲು ಹೊಸ ನೋಡ್). ಒಂದು ವಿಧಾನವು None ಅನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ, ನೋಡ್ ಅನ್ನು AST ಯಿಂದ ತೆಗೆದುಹಾಕಲಾಗುತ್ತದೆ.

AST ಅನ್ನು ಮಾರ್ಪಡಿಸಿದ ನಂತರ, ನೀವು compile() ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಪೈಥಾನ್ ಕೋಡ್ ಆಗಿ ಕಂಪೈಲ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

            import ast

class AddOneTransformer(ast.NodeTransformer):
    def visit_Num(self, node):
        return ast.Num(n=node.n + 1)

code = """
x = 10
y = 20
"""

ast_tree = ast.parse(code)

transformer = AddOneTransformer()
new_ast_tree = transformer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

print(x)  # Output: 11
print(y)  # Output: 21
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, AddOneTransformer ast.NodeTransformer ನಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತದೆ ಮತ್ತು visit_Num ವಿಧಾನವನ್ನು ಓವರ್‌ರೈಡ್ ಮಾಡುತ್ತದೆ. ಈ ವಿಧಾನವನ್ನು ಪ್ರತಿ ಸಂಖ್ಯಾತ್ಮಕ ಲಿಟರಲ್ ನೋಡ್‌ಗಾಗಿ (ast.Num) ಕರೆಯಲಾಗುತ್ತದೆ. ವಿಧಾನವು ಮೌಲ್ಯವನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಿದ ಹೊಸ ast.Num ನೋಡ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. visit() ವಿಧಾನವು ಮಾರ್ಪಡಿಸಿದ AST ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

compile() ಫಂಕ್ಷನ್ ಮಾರ್ಪಡಿಸಿದ AST, ಫೈಲ್‌ಹೆಸರನ್ನು (ಈ ಸಂದರ್ಭದಲ್ಲಿ <string>, ಕೋಡ್ ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಬಂದಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ) ಮತ್ತು ಎಕ್ಸಿಕ್ಯೂಶನ್ ಮೋಡ್ ಅನ್ನು (ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು 'exec') ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇದು exec() ಫಂಕ್ಷನ್ ಬಳಸಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ವಸ್ತುವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು ಬದಲಾಯಿಸುವುದು

            import ast

class VariableNameReplacer(ast.NodeTransformer):
    def __init__(self, old_name, new_name):
        self.old_name = old_name
        self.new_name = new_name

    def visit_Name(self, node):
        if node.id == self.old_name:
            return ast.Name(id=self.new_name, ctx=node.ctx)
        return node

code = """
def multiply_by_two(number):
    return number * 2

result = multiply_by_two(5)
print(result)
"""

ast_tree = ast.parse(code)

replacer = VariableNameReplacer('number', 'num')
new_ast_tree = replacer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Execute the modified code
exec(new_code)

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ವೇರಿಯಬಲ್ ಹೆಸರು 'number' ನ ಎಲ್ಲಾ ನಿದರ್ಶನಗಳನ್ನು 'num' ನೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ. VariableNameReplacer ಹಳೆಯ ಮತ್ತು ಹೊಸ ಹೆಸರುಗಳನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಪ್ರತಿ ಹೆಸರು ನೋಡ್‌ಗಾಗಿ visit_Name ವಿಧಾನವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ. ನೋಡ್‌ನ ಐಡೆಂಟಿಫೈಯರ್ ಹಳೆಯ ಹೆಸರಿಗೆ ಹೊಂದಿಕೆಯಾದರೆ, ಅದು ಹೊಸ ಹೆಸರು ಮತ್ತು ಅದೇ ಸಂದರ್ಭದೊಂದಿಗೆ (node.ctx) ಹೊಸ ast.Name ನೋಡ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಸಂದರ್ಭವು ಹೆಸರನ್ನು ಹೇಗೆ ಬಳಸಲಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ (ಉದಾ., ಲೋಡ್ ಮಾಡುವುದು, ಸಂಗ್ರಹಿಸುವುದು).

AST ಯಿಂದ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವುದು

compile() AST ಯಿಂದ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸಿದರೂ, ಕೋಡ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಪಡೆಯಲು ಇದು ಯಾವುದೇ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ. AST ಯಿಂದ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು, ನೀವು astunparse ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಬಹುದು. ಈ ಲೈಬ್ರರಿಯು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯ ಭಾಗವಾಗಿಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ಮೊದಲು ಅದನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ:

            pip install astunparse
            

              
                Copy
              
            
          

ನಂತರ, ನೀವು AST ಯಿಂದ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು astunparse.unparse() ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಬಹುದು.

            import ast
import astunparse

code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)

generated_code = astunparse.unparse(ast_tree)

print(generated_code)
            

              
                Copy
              
            
          

ಔಟ್‌ಪುಟ್ ಹೀಗಿರುತ್ತದೆ:

            def add(x, y):
    return (x + y)

            

              
                Copy
              
            
          

ಗಮನಿಸಿ: (x + y) ಸುತ್ತಲಿನ ಆವರಣಗಳನ್ನು ಸರಿಯಾದ ಆಪರೇಟರ್ ಪ್ರಾಶಸ್ತ್ಯವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು astunparse ಸೇರಿಸುತ್ತದೆ. ಈ ಆವರಣಗಳು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಗತ್ಯವಿಲ್ಲದಿರಬಹುದು, ಆದರೆ ಅವು ಕೋಡ್‌ನ ಸರಿಯಾದತೆಯನ್ನು ಖಾತರಿಪಡಿಸುತ್ತವೆ.

ಉದಾಹರಣೆ: ಒಂದು ಸರಳ ತರಗತಿಯನ್ನು ಉತ್ಪಾದಿಸುವುದು

            import ast
import astunparse

class_name = 'MyClass'
method_name = 'my_method'

# Create the class definition node
class_def = ast.ClassDef(
    name=class_name,
    bases=[],
    keywords=[],
    body=[
        ast.FunctionDef(
            name=method_name,
            args=ast.arguments(
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                ast.Pass()
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    decorator_list=[]
)

# Create the module node containing the class definition
module = ast.Module(body=[class_def], type_ignores=[])

# Generate the code
code = astunparse.unparse(module)

print(code)
            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ಕೆಳಗಿನ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ:

            class MyClass:

    def my_method():
        pass

            

              
                Copy
              
            
          

ಇದು ಸ್ಕ್ರಾಚ್‌ನಿಂದ AST ಅನ್ನು ನಿರ್ಮಿಸುವುದು ಮತ್ತು ನಂತರ ಅದರಿಂದ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಉತ್ಪಾದಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಕೋಡ್ ಉತ್ಪಾದನಾ ಪರಿಕರಗಳು ಮತ್ತು ಮೆಟಾಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಪ್ರಬಲವಾಗಿದೆ.

ast ಮಾಡ್ಯೂಲ್‌ನ ಪ್ರಾಯೋಗಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು

ast ಮಾಡ್ಯೂಲ್ ಹಲವಾರು ಪ್ರಾಯೋಗಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೊಂದಿದೆ, ಅವುಗಳೆಂದರೆ:

• ಕೋಡ್ ವಿಶ್ಲೇಷಣೆ: ಶೈಲಿ ಉಲ್ಲಂಘನೆಗಳು, ಭದ್ರತಾ ದೋಷಗಳು ಅಥವಾ ಕಾರ್ಯಕ್ಷಮತೆಯ ಕುತ್ತುಗಳಿಗಾಗಿ ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು. ಉದಾಹರಣೆಗೆ, ದೊಡ್ಡ ಯೋಜನೆಯಲ್ಲಿ ಕೋಡಿಂಗ್ ಮಾನದಂಡಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ನೀವು ಒಂದು ಪರಿಕರವನ್ನು ಬರೆಯಬಹುದು.
• ಸ್ವಯಂಚಾಲಿತ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್: ವೇರಿಯೇಬಲ್‌ಗಳ ಹೆಸರನ್ನು ಬದಲಾಯಿಸುವುದು, ವಿಧಾನಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು ಅಥವಾ ಹೊಸ ಭಾಷಾ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಲು ಕೋಡ್ ಅನ್ನು ಪರಿವರ್ತಿಸುವುದು ಮುಂತಾದ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು. `rope` ನಂತಹ ಪರಿಕರಗಳು ಪ್ರಬಲ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳಿಗಾಗಿ AST ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತವೆ.
• ಸ್ಥಿರ ವಿಶ್ಲೇಷಣೆ: ಕೋಡ್ ಅನ್ನು ವಾಸ್ತವವಾಗಿ ರನ್ ಮಾಡದೆ ಸಂಭಾವ್ಯ ದೋಷಗಳು ಅಥವಾ ದೋಷಗಳನ್ನು ಗುರುತಿಸುವುದು. `pylint` ಮತ್ತು `flake8` ನಂತಹ ಪರಿಕರಗಳು ಸಮಸ್ಯೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು AST ವಿಶ್ಲೇಷಣೆಯನ್ನು ಬಳಸುತ್ತವೆ.
• ಕೋಡ್ ಉತ್ಪಾದನೆ: ಟೆಂಪ್ಲೇಟ್‌ಗಳು ಅಥವಾ ವಿಶೇಷಣಗಳ ಆಧಾರದ ಮೇಲೆ ಕೋಡ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಉತ್ಪಾದಿಸುವುದು. ಇದು ಪುನರಾವರ್ತಿತ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ಅಥವಾ ವಿಭಿನ್ನ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಿಗಾಗಿ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಉಪಯುಕ್ತವಾಗಿದೆ.
• ಭಾಷಾ ವಿಸ್ತರಣೆಗಳು: ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ವಿಭಿನ್ನ ಪ್ರಾತಿನಿಧ್ಯಗಳಾಗಿ ಪರಿವರ್ತಿಸುವ ಮೂಲಕ ಕಸ್ಟಮ್ ಭಾಷಾ ವಿಸ್ತರಣೆಗಳು ಅಥವಾ ಡೊಮೇನ್-ನಿರ್ದಿಷ್ಟ ಭಾಷೆಗಳನ್ನು (DSL ಗಳು) ರಚಿಸುವುದು.
• ಭದ್ರತಾ ಆಡಿಟಿಂಗ್: ಸಂಭಾವ್ಯವಾಗಿ ಹಾನಿಕಾರಕ ರಚನೆಗಳು ಅಥವಾ ದುರ್ಬಲತೆಗಳಿಗಾಗಿ ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು. ಇದನ್ನು ಅಭದ್ರ ಕೋಡಿಂಗ್ ಅಭ್ಯಾಸಗಳನ್ನು ಗುರುತಿಸಲು ಬಳಸಬಹುದು.

ಉದಾಹರಣೆ: ಕೋಡಿಂಗ್ ಶೈಲಿಯನ್ನು ಜಾರಿಗೊಳಿಸುವುದು

ನಿಮ್ಮ ಯೋಜನೆಯಲ್ಲಿನ ಎಲ್ಲಾ ಫಂಕ್ಷನ್ ಹೆಸರುಗಳು snake_case ಕನ್ವೆನ್ಷನ್ ಅನ್ನು ಅನುಸರಿಸಬೇಕೆಂದು ನೀವು ಜಾರಿಗೊಳಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಹೇಳೋಣ (ಉದಾ., my_function ಬದಲಿಗೆ myFunction). ಉಲ್ಲಂಘನೆಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ನೀವು ast ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಬಹುದು.

            import ast
import re

class SnakeCaseChecker(ast.NodeVisitor):
    def __init__(self):
        self.errors = []

    def visit_FunctionDef(self, node):
        if not re.match(r'^[a-z]+(_[a-z]+)*$', node.name):
            self.errors.append(f"Function name '{node.name}' does not follow snake_case convention")

    def check_code(self, code):
        ast_tree = ast.parse(code)
        self.visit(ast_tree)
        return self.errors

# Example usage
code = """
def myFunction(x):
    return x * 2

def calculate_area(width, height):
    return width * height
"""

checker = SnakeCaseChecker()
errors = checker.check_code(code)

if errors:
    for error in errors:
        print(error)
else:
    print("No style violations found")
            

              
                Copy
              
            
          

ಈ ಕೋಡ್ SnakeCaseChecker ತರಗತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಅದು ast.NodeVisitor ನಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುತ್ತದೆ. visit_FunctionDef ವಿಧಾನವು ಫಂಕ್ಷನ್ ಹೆಸರು snake_case ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು errors ಪಟ್ಟಿಗೆ ದೋಷ ಸಂದೇಶವನ್ನು ಸೇರಿಸುತ್ತದೆ. check_code ವಿಧಾನವು ಕೋಡ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ, AST ಅನ್ನು ಹಾದುಹೋಗುತ್ತದೆ ಮತ್ತು ದೋಷಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ast ಮಾಡ್ಯೂಲ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• AST ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: AST ಅನ್ನು ಮಾರ್ಪಡಿಸಲು ಪ್ರಯತ್ನಿಸುವ ಮೊದಲು, ast.dump() ಬಳಸಿ ಅದರ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಿ. ಇದು ನೀವು ಕೆಲಸ ಮಾಡಬೇಕಾದ ನೋಡ್‌ಗಳನ್ನು ಗುರುತಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ast.NodeVisitor ಮತ್ತು ast.NodeTransformer ಬಳಸಿ: ಈ ತರಗತಿಗಳು ಮರವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನ್ಯಾವಿಗೇಟ್ ಮಾಡದೆಯೇ AST ಅನ್ನು ಟ್ರಾವರ್ಸ್ ಮಾಡಲು ಮತ್ತು ಮಾರ್ಪಡಿಸಲು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತವೆ.
• ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ: AST ಅನ್ನು ಮಾರ್ಪಡಿಸುವಾಗ, ಬದಲಾವಣೆಗಳು ಸರಿಯಾಗಿವೆಯೇ ಮತ್ತು ಯಾವುದೇ ದೋಷಗಳನ್ನು ಪರಿಚಯಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ.
• ಕೋಡ್ ಉತ್ಪಾದನೆಗಾಗಿ astunparse ಅನ್ನು ಪರಿಗಣಿಸಿ: ಮಾರ್ಪಡಿಸಿದ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು compile() ಉಪಯುಕ್ತವಾಗಿದ್ದರೂ, astunparse AST ಯಿಂದ ಓದಬಲ್ಲ ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
• ಟೈಪ್ ಹಿಂಟ್ಸ್ ಬಳಸಿ: ಟೈಪ್ ಹಿಂಟ್ಸ್ ನಿಮ್ಮ ಕೋಡ್‌ನ ಓದುವಿಕೆ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ AST ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ.
• ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡಿ: ಕಸ್ಟಮ್ AST ವಿಸಿಟರ್‌ಗಳು ಅಥವಾ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್‌ಗಳನ್ನು ರಚಿಸುವಾಗ, ಪ್ರತಿ ವಿಧಾನದ ಉದ್ದೇಶ ಮತ್ತು ಅದು AST ಗೆ ಮಾಡುವ ಬದಲಾವಣೆಗಳನ್ನು ವಿವರಿಸಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಡಾಕ್ಯುಮೆಂಟ್ ಮಾಡಿ.

ಸವಾಲುಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು

• ಸಂಕೀರ್ಣತೆ: AST ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಸಂಕೀರ್ಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಕೋಡ್‌ಬೇಸ್‌ಗಳಿಗೆ. ವಿಭಿನ್ನ ನೋಡ್ ಪ್ರಕಾರಗಳು ಮತ್ತು ಅವುಗಳ ಸಂಬಂಧಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸವಾಲಾಗಿರಬಹುದು.
• ನಿರ್ವಹಣೆ: AST ರಚನೆಗಳು ಪೈಥಾನ್ ಆವೃತ್ತಿಗಳ ನಡುವೆ ಬದಲಾಗಬಹುದು. ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವಿಭಿನ್ನ ಪೈಥಾನ್ ಆವೃತ್ತಿಗಳೊಂದಿಗೆ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಕಾರ್ಯಕ್ಷಮತೆ: ದೊಡ್ಡ AST ಗಳನ್ನು ಟ್ರಾವರ್ಸ್ ಮಾಡುವುದು ಮತ್ತು ಮಾರ್ಪಡಿಸುವುದು ನಿಧಾನವಾಗಬಹುದು. ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಪರಿಗಣಿಸಿ. ಆಗಾಗ್ಗೆ ಪ್ರವೇಶಿಸುವ ನೋಡ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಅಥವಾ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸುವುದು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ದೋಷ ನಿರ್ವಹಣೆ: AST ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವಾಗ ಅಥವಾ ಮಾರ್ಪಡಿಸುವಾಗ ದೋಷಗಳನ್ನು ಸಲೀಸಾಗಿ ನಿರ್ವಹಿಸಿ. ಬಳಕೆದಾರರಿಗೆ ತಿಳಿವಳಿಕೆಯುಳ್ಳ ದೋಷ ಸಂದೇಶಗಳನ್ನು ನೀಡಿ.
• ಭದ್ರತೆ: AST ಯಿಂದ ಉತ್ಪತ್ತಿಯಾಗುವ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ಜಾಗರೂಕರಾಗಿರಿ, ವಿಶೇಷವಾಗಿ AST ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಆಧರಿಸಿದ್ದರೆ. ಕೋಡ್ ಇಂಜೆಕ್ಷನ್ ದಾಳಿಯನ್ನು ತಡೆಗಟ್ಟಲು ಇನ್‌ಪುಟ್ ಅನ್ನು ಸ್ಯಾನಿಟೈಸ್ ಮಾಡಿ.

ತೀರ್ಮಾನ

ಪೈಥಾನ್ ast ಮಾಡ್ಯೂಲ್ ಪೈಥಾನ್ ಕೋಡ್‌ನ ಅಮೂರ್ತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ ಜೊತೆಗೆ ಸಂವಹನ ನಡೆಸಲು ಪ್ರಬಲ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. AST ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ast.NodeVisitor ಮತ್ತು ast.NodeTransformer ತರಗತಿಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ನೀವು ಪೈಥಾನ್ ಕೋಡ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ವಿಶ್ಲೇಷಿಸಬಹುದು, ಮಾರ್ಪಡಿಸಬಹುದು ಮತ್ತು ಉತ್ಪಾದಿಸಬಹುದು. ಇದು ಕೋಡ್ ವಿಶ್ಲೇಷಣೆ ಪರಿಕರಗಳಿಂದ ಹಿಡಿದು ಸ್ವಯಂಚಾಲಿತ ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಮತ್ತು ಕಸ್ಟಮ್ ಭಾಷಾ ವಿಸ್ತರಣೆಗಳವರೆಗೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಬಾಗಿಲು ತೆರೆಯುತ್ತದೆ. AST ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಸಂಕೀರ್ಣವಾಗಿದ್ದರೂ, ಪ್ರೋಗ್ರಾಮಿಕ್ ಆಗಿ ಕೋಡ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುವ ಸಾಮರ್ಥ್ಯದ ಪ್ರಯೋಜನಗಳು ಮಹತ್ವದ್ದಾಗಿವೆ. ನಿಮ್ಮ ಪೈಥಾನ್ ಯೋಜನೆಗಳಲ್ಲಿ ಹೊಸ ಸಾಧ್ಯತೆಗಳನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಲು ast ಮಾಡ್ಯೂಲ್‌ನ ಶಕ್ತಿಯನ್ನು ಸ್ವೀಕರಿಸಿ.